package org.example.camundaapp.controller;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.camunda.bpm.engine.task.Task;
import org.example.camundaapp.dto.TaskDTO;
import org.example.camundaapp.service.CamundaTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Map;

/**
 * 任务管理模块
 * @className: TaskController
 * @author: ZHRJ
 * @date: 2025-07-04 11:30
 * @Version: 1.0
 * @description:
 */
@RestController
@RequestMapping("/api/task")
@Slf4j
public class TaskController {

    private CamundaTaskService camundaTaskService;

    @Autowired
    public TaskController(CamundaTaskService camundaTaskService) {
        this.camundaTaskService = camundaTaskService;
    }

    /**
     * 获取用户任务列表
     * @param variables 查询参数 userId（必填）,taskName,taskStatus:1-已完成，0-待处理
     * @return
     */
    @PostMapping("/userTasks")
    public ResponseEntity<List<TaskDTO>> getUserTasks( @RequestBody Map<String, Object> variables) {
        String userId = (String) variables.get("userId");
        String taskName = (String) variables.get("taskName");
        String taskStatus = (String) variables.get("taskStatus");
        List<TaskDTO> tasks = camundaTaskService.getUserTasks(userId,taskName,taskStatus);
        log.info("获取用户任务列表，用户ID：{}，任务列表：{}", userId, JSON.toJSONString(tasks));
        return ResponseEntity.ok(tasks);
    }

    /**
     * 查询待办任务列表 （推荐）
     * @param userId 用户 ID
     * @param processInstanceId 流程实例 ID（可选）
     * @return 待办任务列表
     */
    @GetMapping("/pendingTasks")
    public ResponseEntity<List<TaskDTO>> getPendingTasks(
            @RequestParam String userId,
            @RequestParam(required = false) String processInstanceId) {
        List<TaskDTO> tasks = camundaTaskService.getPendingTasks(userId, processInstanceId);
        log.info("查询待办任务列表，用户 ID：{}，流程实例 ID：{}，任务列表：{}", userId, processInstanceId, JSON.toJSONString(tasks));
        return ResponseEntity.ok(tasks);
    }
    /**
     * 获取用户任务列表
     * GET /api/task/list?userId=manager1
     * @param userId
     * @return
     * [
     *   {
     *     "taskId": "task-123",
     *     "taskName": "经理审批",
     *     "processInstanceId": "process-456"
     *   }
     * ]
     */
    @GetMapping("/list")
    public ResponseEntity<List<Map<String, Object>>> getTasksByUser(
            @RequestParam String userId) {

        List<Map<String, Object>> result = camundaTaskService.getUserTasks(userId);

        return ResponseEntity.ok(result);
    }

    //通过流程实例获取用户任务列表
    @GetMapping("/listByProcessInstanceId")
    public ResponseEntity<List<TaskDTO>> getTasksByProcessInstanceId(
            @RequestParam String processInstanceId) {
        List<TaskDTO> result = camundaTaskService.queryTasksByInstanceId(processInstanceId);
        return ResponseEntity.ok(result);
    }
    //通过指定的流程变量获取用户任务列表
    @GetMapping("/listByInitiator")
    public ResponseEntity<List<TaskDTO>> getTasksByInitiator(
            @RequestParam String variableName,
            @RequestParam String variableValue) {
        List<TaskDTO> result = camundaTaskService.queryTasksByInitiator(variableName, variableValue);
        return ResponseEntity.ok(result);
    }



    /**
     *  审批任务（通过/拒绝）
     *  POST /api/task/complete?taskId=task-123&approve=true
     *  {
     *   "comment": "同意申请"
     * }
     * @param taskId
     * @param approve
     * @param variables
     * @return
     */
    @PostMapping("/complete")
    public ResponseEntity<String> completeTask(
            @RequestParam String taskId,
            @RequestParam(required = false) Boolean approve,
            @RequestBody(required = false) Map<String, Object> variables) {
        camundaTaskService.completeTask(taskId, approve, variables);
        return ResponseEntity.ok("任务审批完成");
    }

    /**
     * 完成审批任务 （推荐）
     * @param requestBody 请求体，包含任务 ID、审批人、审批决定、审批意见和流程变量
     * {
     *   "taskId": "a3d8f7b2-1c5e-4a9d-bf82-7c1e9f3a6b0d", // 待处理的任务id
     *   "approver": "lisi", // 当前审批人id
     *   "decision": "APPROVED", // 审批决定（APPROVED/REJECTED）
     *   "comment": "申请材料完整，符合要求", // 审批意见
     *   "variables": { // 需要更新的流程变量
     *     "days": 5,
     *     "amount": 15000.00
     *   }
     * }
     * @return 完成任务的结果信息
     */
    @PostMapping("/completeTask")
    public ResponseEntity<String> completeTask(@RequestBody JSONObject requestBody) {
        String taskId = requestBody.getString("taskId");
        String approver = requestBody.getString("approver");
        String decision = requestBody.getString("decision");
        String comment = requestBody.getString("comment");
        Map<String, Object> variables = requestBody.getObject("variables", Map.class);

        log.info("完成审批任务，任务 ID：{}，审批人：{}，审批决定：{}，审批意见：{}，流程变量：{}",
                taskId, approver, decision, comment, variables);

        camundaTaskService.completeApprovalTask(taskId, approver, decision, comment, variables);
        return ResponseEntity.ok("审批任务完成");
    }


    /**
     *  完成任务
     * @param taskId 任务id
     * @param variables 流程变量
     * @return 完成结果
     */
    @PostMapping("/completeTask/{taskId}")
    public ResponseEntity<String> completeTask(
            @PathVariable String taskId,
            @RequestBody Map<String, Object> variables

    ) {
        camundaTaskService.completeTask(taskId, variables);
        return ResponseEntity.ok("任务已审批完成");
    }

    /**
     * 跳转任务（跳转到指定节点，自由流）
     * @param currentTaskId 当前任务ID
     * @param targetNodeId 目标任务ID
     * @return
     */
    @PostMapping("/jump")
    public ResponseEntity<String> jumpTask(
            @RequestParam String currentTaskId,
            @RequestParam String targetNodeId
    ) {
        camundaTaskService.jumpTask(currentTaskId, targetNodeId);
        return ResponseEntity.ok("任务跳转成功");
    }

    /**
     * 多人并行审批任务查询
     * @param processInstanceId 流程实例ID
     * @return
     */
    @GetMapping("/parallelTasks")
    public ResponseEntity<List<TaskDTO>> getParallelTasks(
            @RequestParam String processInstanceId,
            @RequestParam(required = false) String assignee
    ) {
        List<TaskDTO> tasks = camundaTaskService.getParallelTasks(processInstanceId,assignee);
        return ResponseEntity.ok(tasks);
    }

    /**
     * 认领任务
     * @param taskId 任务id
     * @param assignee 任务认领人id
     * @return
     */
    @PostMapping("/claimTask")
    public ResponseEntity<String> claimTask(
            @RequestParam String taskId,
            @RequestParam String assignee
    ) {
        camundaTaskService.claimTask(taskId, assignee);
        return ResponseEntity.ok("任务认领成功");
    }


    /**
     * 为任务添加新的候选人
     * 实现动态变更候选人，在流程中添加新候选人的功能
     * {
     *   "taskId": "task1",
     *   "candidateUsers": ["zhouwu"]
     * }
     * @return 添加候选人的结果信息
     */
    @PostMapping("/addCandidate")
    public ResponseEntity<String> addCandidateUsers(@RequestBody JSONObject requestBody) {
        String taskId = requestBody.getString("taskId");
        List<String> candidateUsers = requestBody.getList("candidateUsers", String.class);

        log.info("为任务 {} 添加新候选人: {}", taskId, candidateUsers);

        camundaTaskService.addCandidateUsers(taskId, candidateUsers);
        return ResponseEntity.ok("新候选人添加成功");
    }

    /**
     * 获取指定用户的候选任务列表
     * 和/pendingTasks接口不一样，/pendingTasks接口是查询已指定用户的待办任务，而候选人和任务之间在没有认领前都是弱关系，需要查询候选任务列表
     * @param userId 用户id
     * @return
     */
    @GetMapping("/candidateTasks")
    public ResponseEntity<List<TaskDTO>> getCandidateTasks(
            @RequestParam String userId
    ) {
        List<TaskDTO> tasks = camundaTaskService.getCandidateTasks(userId);
        return ResponseEntity.ok(tasks);
    }

    /**
     * 查询当前任务状态
     * @param taskId 任务 ID
     * @return 任务状态信息
     */
    @GetMapping("/status")
    public ResponseEntity<String> getTaskStatus(@RequestParam String taskId) {
        String status = camundaTaskService.getTaskCurrentStatus(taskId);
        return ResponseEntity.ok(status);
    }

}
